<!DOCTYPE html>
<html>
<head>
	<title>原型和原型链</title>
	<meta charset="utf-8">
</head>
<body>
1.对象分为两种，普通对象和函数对象。
<script>
// 1.对象分为两种，普通对象和函数对象。
    // function test1(){}
    // var test2=function(){};
    // var test3=new Function();
    // var test4=Function();

    // console.log(typeof test1);//function
    // console.log(typeof test2);//function
    // console.log(typeof test3);//function
    // console.log(typeof test4);//function

    // var str1="123";
    // var str2=new String("123");

    // var num1=new Number(3);
    // var num2=Number(3);
    // var num3=3

    // var arr1=new Array();
    // var arr2=Array();

    // var bool1=new Boolean();
    // var bool2=Boolean();

    // var obj1=new Object();
    // var obj2={};
    // var obj3=new test1();
    // var obj4=Object();

    // console.log(typeof obj1);//object;
    // console.log(typeof obj2);//object
    // console.log(typeof obj3);//object;
    // console.log(typeof obj4);//object


    // function Person(){
        
    // }
    // var yan=new Person();
</script>

<script>
	// 普通对象和函数对象的区别
 //     1.普通对象里使用存在一个隐式属性（__prot__）;
 //     2.函数对象里始终有一个属性prototype（原型）同时还存在隐式属性（__proto__）
 //     3.普通对象的__proto__指向了构造函数的原型

	// var obj={};
	// function Test(){}
	// var s=new Test();
	// console.log(s.__proto__==Test.prototype)

</script>

2.如何判断对象的数据类型

<script>
    // 2.如何判断对象的数据类型
    // var arr=new Array();
    // console.log(typeof arr);
    // console.log(arr instanceof Array);

    // var obj=new Object();
    // console.log(typeof obj);
    // console.log(obj instanceof Object);

    // var date=new Date();
    // console.log(typeof date);
    // console.log(date instanceof Date);
</script>

对象都有属性和方法

    prototype本身就是一个对象--原型对象
    prototype里有一个属性constructor--构造器。指向了构造函数。
    普通对象的__proto__指向了构造器的原型对象。
    构造函数构造出来的对象继承了构造函数原型上的一切属性和方法。

原型：
    概念:函数里的一个属性，它定义了公共属性。这个属性本身也是一个对象。
    prototype:构造函数构造出了一个公共祖先。

<script>   
    // prototype本身就是一个对象--原型对象
    // prototype里有一个属性constructor--构造器。指向了构造函数。
    // 普通对象的__proto__指向了构造器的原型对象。
    // 构造函数构造出来的对象继承了构造函数原型上的一切属性和方法。
    function Person(){

    }
    Person.prototype={
        youxij:"bbb",
        parent:"bab",
        money:"1232314"
    }
    var yan=new Person();
    console.log(yan.youxij);

</script>
<script>
// 如果自身没有指定的属性或者方法，然后去原型找
    // var name="yan";
    // function Person(name,age){
    //     this.age=age;
    //     this.name=name;
    // }
    // Person.prototype.name="ccc";
    // Person.prototype.run=function(){
    //     console.log(this.name+"在干活");
    // }
    // var stu=new Person("miao",20);
    // console.log(stu.name);
    // console.log(stu.age);
    // console.log(stu.run());
</script>
<script>
    function Person(name,age){
        this.age=age;
        this.name=name;
    }
    var stu=new Person("miao",20);
    // 原型重写
    Person.prototype={
        name:"ccc",
        run:function(){
            console.log(this.name+"在干活");
        }
    }
    // 原型修改
    // Person.prototype.name="ccc";
    // Person.prototype.run=function(){
    //     console.log(this.name+"在干活");
    // }

    console.log(stu.name);
    console.log(stu.age)
    console.log(stu.run());

</script>

所有函数的原型对象都继承原始对象（Object.prototype);
原始对象（Object.prototype）的__proto__的值为null.

function.prototype==function.
Object,String,Number的__proto__都指向function

所有的对象的原型对象的隐式原型都指向原始对象。（原始对象除外）=====elem.prototype.__proto__==Object.prototype;
</body>
</html>